package futbol.tacticas.concursantes2007.SquandragoCF;

import futbol.tacticas.concursantes.Tactica;

import java.awt.Color;
import java.awt.Point;
import java.util.Vector;
import futbol.tacticas.*;
import futbol.General;

public class TacticaSquandrago implements Tactica {
  //vector de fuerza de tiro
  private int nFuerza[] = {
    4, //jugador 1
    5, //jugador 2
    5, //jugador 3
    5, //jugador 4
    5, //jugador 5
    5, //jugador 6
    4, //jugador 7
    6, //jugador 8
    7, //jugador 9
    7, //jugador 10
    7, //jugador 11
  };
  
  //tactica 4-4-2 en rombo
  private int nValores2[][] = {
    //4-4-2 en rombo
    {-150,0},		//Jugador 1
    {-60,-65},	//Jugador 2
    {-95,-25},	//Jugador 3
    {-55,0},		//Jugador 4
    {-95,25},         //Jugador 5
    {-60,65},		//Jugador 6
    {15,0},		//Jugador 7
    {20,-65},		//Jugador 8
    {20,65},		//Jugador 9
    {95,-40},		//Jugador 10
    {95,40}		//Jugador 11
  };
  //tactica 4-2-3-1
  private int nValores1[][] = {
    {-150,0},		//Jugador 1
    {-60,-65},	//Jugador 2
    {-90,-20},	//Jugador 3
    {-30,-25},	//Jugador 4
    {-90,20},         //Jugador 5
    {-60,65},		//Jugador 6
    {-30,25},		//Jugador 7
    {40,0},		//Jugador 8
    {25,70},		//Jugador 9
    {25,-70},		//Jugador 10
    {105,0}		//Jugador 11
  };
  
  //tactica 4-3-2-1
  private int nValores3[][] = {
    {-150,0},		//Jugador 1
    {0,-80},	//Jugador 2
    {-105,-20},	//Jugador 3
    {-45,-35},	//Jugador 4
    {-105,20},         //Jugador 5
    {0,80},		//Jugador 6
    {-45,35},		//Jugador 7
    {35,-35},		//Jugador 8
    {35,35},		//Jugador 9
    {90,-35},		//Jugador 10
    {90,35}		//Jugador 11
  };
  
  //zona 4-4-2
  private int zonaJugadores2[][] = {
    //4-4-2 en rombo
    {0,0},              //Jugador 1
    {30,30},            //Jugador 2
    {20,20},            //Jugador 3
    {40,30},            //Jugador 4
    {20,20},            //Jugador 5
    {30,30},            //Jugador 6
    {60,30},            //Jugador 7
    {30,40},            //Jugador 8
    {40,40},            //Jugador 9
    {30,35},            //Jugador 10
    {30,35},            //Jugador 11
  };
  
  //zona 4-2-3-1
  private int zonaJugadores1[][] = {
    //4-2-3-1
    {0,0},              //Jugador 1
    {30,30},            //Jugador 2
    {15,20},            //Jugador 3
    {30,30},            //Jugador 4
    {15,20},            //Jugador 5
    {30,30},            //Jugador 6
    {30,30},            //Jugador 7
    {70,40},            //Jugador 8
    {50,20},            //Jugador 9
    {50,20},            //Jugador 10
    {30,35},            //Jugador 11
  };
  
  private int zonaJugadores3[][] = {
    //4-3-2-1
    {0,0},              //Jugador 1
    {100,30},            //Jugador 2
    {10,15},            //Jugador 3
    {30,30},            //Jugador 4
    {10,15},            //Jugador 5
    {100,30},            //Jugador 6
    {30,30},            //Jugador 7
    {30,30},            //Jugador 8
    {30,30},            //Jugador 9
    {25,25},            //Jugador 10
    {25,25},            //Jugador 11
  };
  
  private int xBolaAnt = 0; //posicion anterior X del balon. 0 al iniciar
  private int yBolaAnt = 0; //posicion anterior Y del balon. 0 al iniciar
  private int nJugCercanoPrevisto = 0; //mi jugador mas cercano al lugar previsto de blla
  private int velocidadBola = 0; //velocidad a la que va la bola
  private int difgoles = 0; //controla la diferencia de goles.
  private int iTactica = 0; //controla la tactica que pongo
  final int JUG_PASES = 5; //cuantos jugadores calculo para el pase
  final int ANCHO = 25; //ancho de la zona de pase
  final int DISPASE = 20; //distancia a la que se da el autopase
  final int DISRIVAL = DISPASE*2 + 5; //distancia minima a la que estara el rival para un autopase
  
  public String getNombre() {
    return "Squandrago";
  }
  
  public Color getColor1() {
    return Color.BLACK;
  }
  
  public Color getColor2() {
    return Color.BLACK;
  }
  
  public Color getColorNumero() {
    return Color.WHITE;
  }
  
  public int getFuerza(int n) {
    return nFuerza[n];
  }
  
  public int getXInicial(int n) {
    int valor=0;
    
    if (iTactica%3 == 0) valor = nValores1[n][0];
    else if (iTactica%3 == 1) valor = nValores2[n][0];
    else if (iTactica%3 == 2) valor = nValores3[n][0];
    
    return valor;
  }
  
  public int getYInicial(int n) {
    int valor=0;
    
    if (iTactica%3 == 0) valor = nValores1[n][1];
    else if (iTactica%3 == 1) valor = nValores2[n][1];
    else if (iTactica%3 == 2) valor = nValores3[n][1];
    
    return valor;
  }
  
  public Vector<Comando> getComandos(SituacionJugadores sj) {
    Vector<Comando> com = new Vector();
    Point bola; //posicion del balon
    Point misJugadores[];
    int nJugCercano; //mi jugador mas cercano
    int nJugCercanoPase = -1; //jugador al que se va a pasar la bola
    int bx, by; //posicion X e Y del balon
    int posTiro; //posicion X del tiro a puerta
    boolean bPuedeGolpear; //indica si puede golpear bola
    double previsionBola[] = {0,0}; //posicion prevista de la bola. [x,y]
    
    bola = sj.getBola();
    bx = (int)(bola.getX());
    by = (int)(bola.getY());
    misJugadores = sj.getMisJugadores();
    
    //BUSQUEDA DEL BALON
    //Mas cercano a bola
    nJugCercano = sj.getMasCercanoDeBola();
    
    //Anticipar movimiento
    if(calcularPosicionBolaPrevista(previsionBola, bx, by)){
      nJugCercanoPrevisto = sj.getMiJugadorMasCerca(previsionBola[0], previsionBola[1]);
      if (nJugCercanoPrevisto == 0) //evito que sea el portero, para no descolocarlo
        nJugCercanoPrevisto = 2;
    }
    
    //el mas cercano a la bola va por ella. El previsto va hacia la posicion
    com.add(new ComandoIrA(nJugCercano, bx, by));
    if (nJugCercano != nJugCercanoPrevisto){
      com.add(new ComandoIrA(nJugCercanoPrevisto,(int)previsionBola[0], (int)previsionBola[1]));
    }
    
    
    //si hay posibilidad de darle al balon, hago todos los calculos
    bPuedeGolpear = (General.getDistancia(bola.getX(), bola.getY(), misJugadores[nJugCercano].getX(), misJugadores[nJugCercano].getY()) < 10);
    if (bPuedeGolpear){
      if (bx < 20){
        nJugCercanoPase = pasesJugadores(com, sj, bola, nJugCercano);
        if (nJugCercanoPase < 0){
          hacerAutopase(sj, com, misJugadores, nJugCercano);
        }
      }
      //distingo si tiro a puerta o no segun fuerza de jugador
      else if (bx >= 20 && bx < 65 && getFuerza(nJugCercano) == 7){ //tiro lejano
        tiroAPuerta(nJugCercano, sj, com);
      } else if (bx >= 20 && bx < 65 && getFuerza(nJugCercano) < 7){ //sigo buscando el pase
        nJugCercanoPase = pasesJugadores(com, sj, bola, nJugCercano);
        if (nJugCercanoPase < 0){
          hacerAutopase(sj, com, misJugadores, nJugCercano);
        }
      } else if (bx >= 65){ //cerca de porteria, tiro sea quien sea
        tiroAPuerta(nJugCercano, sj, com);
      }
    }
    
    //Movimiento general del equipo
    movimientoJugadores(com, nJugCercano, nJugCercanoPase, nJugCercanoPrevisto, bx, by);
    
    //Movimiento portero
    movimientoPortero(com, bx, by);
    
    //calculo del marcador del partido
    marcadorPartido(bx, xBolaAnt);
    
    //actualizo coordenadas anteriores del balon con las actuales
    xBolaAnt = bx;
    yBolaAnt = by;
    
    return com;
  }
  
  
  private boolean calcularPosicionBolaPrevista(double [] previsionBola, int bx, int by){
    double angulo; //calculo el angulo que lleva la bola.
    int velocidad; //velocidad a la que va la bola
    boolean aPorBola = false; //indicar� si merece la pena ir a por la bola o no
    double cosenoAngulo; //para calcularlo solo una vez
    double senoAngulo;
    
    previsionBola[0] = (double)xBolaAnt;
    previsionBola[1] = (double)yBolaAnt;
    
    //hallo la velocidad y el angulo de la bola
    velocidad = (int)(General.getDistancia((double)xBolaAnt, (double)yBolaAnt, (double)bx, (double)by));
    angulo = General.getAngulo((double)xBolaAnt, (double)yBolaAnt, (double)bx, (double)by);
    //a ver si merece la pena adelantarse al movimiento de la bola. Si la velocidad es menor
    //que la calculada anteriormente, es que no la ha tocado nadie. No recalculamos
    if (velocidad >= 1){
      velocidadBola = velocidad;
      aPorBola = true;
      cosenoAngulo = Math.cos(angulo);
      senoAngulo = Math.sin(angulo);
      //simulo la funcion mover de la clase Bola. Tocando el limite del primer bucle me adelanto
      //mas o menos al movimiento de la bola
      for (int i=velocidad; i>5; i--){
        for (int j=0; j<velocidad; j++){
          previsionBola[0] += cosenoAngulo;
          previsionBola[1] += senoAngulo;
          //correcion de angulo
          if (previsionBola[0]>160){
            previsionBola[0]=320-previsionBola[0];  //160 - (x-160)
            angulo=General.corregirAngulo(Math.PI-angulo);
            cosenoAngulo = Math.cos(angulo);
            senoAngulo = Math.sin(angulo);
          }
          if (previsionBola[0]<-160){
            previsionBola[0]=-320-previsionBola[0]; //-160 + (-160-x)
            angulo=General.corregirAngulo(Math.PI-angulo);
            cosenoAngulo = Math.cos(angulo);
            senoAngulo = Math.sin(angulo);
          }
          if (previsionBola[1]>120){
            previsionBola[1]=240-previsionBola[1]; //120 - (x-120)
            angulo=General.corregirAngulo(-angulo);
            cosenoAngulo = Math.cos(angulo);
            senoAngulo = Math.sin(angulo);
          }
          if (previsionBola[1]<-120){
            previsionBola[1]=-240-previsionBola[1];  //-120 + (-120-x)
            angulo=General.corregirAngulo(-angulo);
            cosenoAngulo = Math.cos(angulo);
            senoAngulo = Math.sin(angulo);
          }
        }
      }
    }
    return aPorBola;
  }
  
  
  private void hacerAutopase(SituacionJugadores sj, Vector<Comando> com, Point [] misJugadores, int nJC){
    int autoPaseOptimo[] = {0,0,0}; //distancia al rival, x, y
    int nJCx = (int)(misJugadores[nJC].getX()); //x de mi jugador
    int nJCy = (int)(misJugadores[nJC].getY()); //y de mi jugador
    
    //pruebo primero los casos de avanzar hacia la porteria rival
    pruebaAutopase(sj, nJCx + DISPASE*1, nJCy + DISPASE*0, autoPaseOptimo);
    pruebaAutopase(sj, nJCx + DISPASE*1, nJCy + DISPASE*1, autoPaseOptimo);
    pruebaAutopase(sj, nJCx + DISPASE*1, nJCy + DISPASE*(-1), autoPaseOptimo);
    //con esto doy prioridad al pase hacia adelante siempre que sea bueno
    if (autoPaseOptimo[0] < DISRIVAL){
      pruebaAutopase(sj, nJCx + DISPASE*0, nJCy + DISPASE*(-1), autoPaseOptimo);
      pruebaAutopase(sj, nJCx + DISPASE*0, nJCy + DISPASE*1, autoPaseOptimo);
      pruebaAutopase(sj, nJCx + DISPASE*(-1), nJCy + DISPASE*1, autoPaseOptimo);
      pruebaAutopase(sj, nJCx + DISPASE*(-1), nJCy + DISPASE*0, autoPaseOptimo);
      pruebaAutopase(sj, nJCx + DISPASE*(-1), nJCy + DISPASE*(-1), autoPaseOptimo);
      com.add(new ComandoGolpearBola(nJC, autoPaseOptimo[1], autoPaseOptimo[2]));
    } else
      com.add(new ComandoGolpearBola(nJC, autoPaseOptimo[1], autoPaseOptimo[2]));
  }
  
  
  private void pruebaAutopase(SituacionJugadores sj, int x, int y, int [] autoPaseOptimo){
    int rMC; //rival mas cercano al punto que voy a probar
    int distanciaRival; //a que distancia esta el rival que estoy probando
    Point [] misContrarios; //situacion de los contrarios
    double rMCx, rMCy; //coordenadas del rival mas cercano
    
    //obtengo la informacion que necesito del jugador contrario
    misContrarios = sj.getContrario(); //obtengo los jugadores contrarios
    rMC = sj.getContrarioMasCerca((double)x, (double)y); //obtengo rival mas cercano
    rMCx = misContrarios[rMC].getX();
    rMCy = misContrarios[rMC].getY();
    
    //obtengo la distancia del rival al punto que voy a pasar
    distanciaRival = (int)(General.getDistancia(rMCx, rMCy, (double)x, (double)y));
    if (distanciaRival > autoPaseOptimo[0]){
      autoPaseOptimo[0] = distanciaRival;
      autoPaseOptimo[1] = x;
      autoPaseOptimo[2] = y;
    }
  }
  
  
  private void marcadorPartido(int bx, int xBolaAnt){
    //cambio de posicion el jugador lanzador de la tactica 2, para evitar estadisticas
    if (xBolaAnt > 150 && bx < 40){ 
      difgoles=0;
      nValores2[8][1] = (-1)*nValores2[8][1];
      nValores2[7][1] = (-1)*nValores2[7][1];
    }
    if (xBolaAnt < -150 && bx > -40){ 
      nValores2[8][1] = (-1)*nValores2[8][1];
      nValores2[7][1] = (-1)*nValores2[7][1];
      difgoles--;
    }
    
    //cambio la tactica si marcan dos goles seguidos
    if (difgoles < 0 && difgoles%2 == 0){
      difgoles = 0;
      iTactica++;
    }
  }
  
  
  //calcula la posicion y optima del tiro a puerta
  private void tiroAPuerta(int nJC, SituacionJugadores sj, Vector<Comando> com){
    int nPorteroContrario; //numero de portero contrario
    Point [] contrarios; //array de contrarios
    int posYPortero; //posicion Y de portero rival
    int posTiro;
    
    nPorteroContrario = sj.getContrarioMasCerca(150, 0); //obtengo indice del portero contrario
    contrarios = sj.getContrario();
    posYPortero = (int)(contrarios[nPorteroContrario].getY()); //obtengo pos Y del portero
    //chuto al lado contrario del portero. Corrijo un poco para los tiros mas ajustados al palo
    posTiro = 0 - posYPortero + (posYPortero/5); 
    if (Math.abs(posTiro) <= 5) //el tiro ira centrado. Fuerzo el desvio
      posTiro = (int)(2.5*posTiro);
    
    com.add(new ComandoTiroAPuerta(nJC, posTiro));
  }
  
  private int pasesJugadores(Vector<Comando> com, SituacionJugadores sj, Point bola, int nJugCercano){
    int nJugCercanoPase = -1; //jugador a pasar el balon
    int masCercanos[] = {0,0,0,0,0,0,0,0,0,0,0}; //candidatos a pasar el balon
    int bx; //posicion X del balon
    int by; //posicin Y del balon
    
    bx = (int)(bola.getX());
    by = (int)(bola.getY());
    
    //si no estoy cerca de porteria contrario, busco mas libre
    //if (bx >= -105 && bx < 40 ){
    if (bx < 40){
      //obtengo los JUG_PASES jugadores candidatos a pasar el balon
      obtenerMasCercanos(sj, nJugCercano, masCercanos);
      //obtengo el jugador a pasar. Es el que tenga el contrario mas alejado
      nJugCercanoPase = jugadorAPasar(sj, nJugCercano, masCercanos);
    }
    //cerca de porteria contrario, paso a delanteros. Evito no pasar por marcajes
    else if (bx >= 40){
      nJugCercanoPase = 9 + bx%2; //esto para aleatorio entre 10 y 11
    }
    
    //nJugCercanoPase = 0;
    //si hay jugador al que pasarle, hago el pase
    if (nJugCercanoPase > 0){
      com.add(new ComandoPase(nJugCercano, nJugCercanoPase));
    }
    
    return nJugCercanoPase;
  }
  
  private void obtenerMasCercanos(SituacionJugadores sj, int nJugCercano, int [] masCercanos){
    int excluir[] = {0,0,0,0,0,0,0,0,0,0,0}; //jugadores a quitar de comprobar mas cercanos, incluido el que va a pasar
    int infoCercano[] = {-1,999}; //valores de jugadores mas cercanos
    Point misJugadores[]; //situacion de mis jugadores
    
    excluir[0] = nJugCercano; //excluyo al mas cercano al balon, que dara el pase
    misJugadores = sj.getMisJugadores();
    //obtengo los jugadores mas cercanos al que esta mas cerca del balon
    for (int i=1; i<=JUG_PASES; i++){ //empiezo en 1 para mantener al jugador que tiene la pelota excluido
      infoCercano = sj.getInfoMasCercano(misJugadores, misJugadores[nJugCercano], excluir, true);
      excluir[i] = infoCercano[0]; //quito el obtenido para siguiente iteracion
      //evito el problema de fuera de array.
      if (infoCercano[0] >= 0){ //hay jugador mas adelantado que el pasador
        masCercanos[i-1] = infoCercano[0]; //guardo el mas cercano de esta iteracion
      } //else{ //no hay jugador mas adelantado. Aqui vale -1 y daria error de fuera de array
      //masCercanos[i-1] = 9 + i%2; //posibilidades de pase a los delanteros
      //}
    }
  }
  
  private int jugadorAPasar(SituacionJugadores sj, int nJC, int [] masCercanos){
    Point misJugadores[];
    Point misContrarios[];
    int disContrario = -1;
    int infoContCercano[] = {-1,999}; //{jugador, distancia}
    int nJugCercanoPase = -1; //jugador al que se le pasará la bola
    boolean bEnLineaPase = false; //indica si hay jugador en la linea de pase
    
    misJugadores = sj.getMisJugadores();
    misContrarios = sj.getContrario();
    
    //con la clausula masCercanos[i] > 0 evito que se pase al portero y que pete el algoritmo
    for (int i=0; i<JUG_PASES && masCercanos[i] > 0; i++){
      bEnLineaPase = rivalLineaPase(misJugadores[nJC], misJugadores[masCercanos[i]], misContrarios);
      if (!bEnLineaPase){ //si no esta en linea de pase, calculo distancia al jugador
        //obtengo el contrario mas cercano al jugador que estoy tratando
        //si la distancia a el es menor que para otro, actualizo datos y devuelvo
        infoContCercano = sj.getInfoMasCercano(misContrarios, misJugadores[masCercanos[i]], null, false);
        if (disContrario < infoContCercano[1]){
          disContrario = infoContCercano[1]; //actualizo distancia al contrario
          nJugCercanoPase = masCercanos[i]; //paso a este jugador que tiene el contrario mas lejano
        }
      }
    }
    return nJugCercanoPase;
  }
  
  
  private boolean rivalLineaPase(Point jC, Point jCP, Point misContrarios[]){
    double jCPx, jCPy, jCx, jCy; //coordenadas de jugadores
    double incPase, desPase; //recta de la linea de pase
    double desPaseL, desPaseM; //desplazamiento lineas paralelas
    double incPasePerpendicular; //inclinacion lineas perpendiculares
    double desPaseN, desPaseO; //desplazamiento lineas perpendiculares
    int MOx, MOy, LOx, LOy, MNx, MNy, LNx, LNy; //puntos que definen la zona de pase
    double auxRestaPases; //auxiliar para no escribir tanto
    int jRx, jRy; //coordenadas del jugador rival en curso
    boolean bEnPase=false; //hay un jugador en la linea de pase
    
    // CALCULO DE PASILLO DE PASE
    // ---------------- L
    // |              |
    // |              |
    // ---------------- M
    // N              O
    
    try{
      //obtengo coordenadas de jugadores
      jCPx = jCP.getX();
      jCPy = jCP.getY();
      jCx = jC.getX();
      jCy = jC.getY();
      
      //calcular linea de pase
      incPase = (jCPy - jCy)/(jCPx - jCx);
      desPase = jCy - (jCx*jCPy - jCx*jCy)/(jCPx - jCx);
      //lineas paralelas de pase. Solo necesito el desplazamiento
      desPaseL = desPase + ANCHO;
      desPaseM = desPase - ANCHO;
      //lineas perpendiculares
      incPasePerpendicular = -1/incPase;
      desPaseN = jCy - (jCx*incPasePerpendicular);
      desPaseO = jCPy - (jCPx*incPasePerpendicular);
      //calculo de puntos que definen el area del rectangulo
      auxRestaPases = incPase - incPasePerpendicular;
      MOx = (int)((desPaseO - desPaseM)/auxRestaPases);
      MOy = (int)((incPase * MOx) + desPaseM);
      LOx = (int)((desPaseO - desPaseL)/auxRestaPases);
      LOy = (int)((incPase * LOx) + desPaseL);
      MNx = (int)((desPaseN - desPaseM)/auxRestaPases);
      MNy = (int)((incPase * MNx) + desPaseM);
      LNx = (int)((desPaseN - desPaseL)/auxRestaPases);
      LNy = (int)((incPase * LNx) + desPaseL);
      
      //CALCULO SI HAY JUGADORES RIVALES DENTRO DE LA ZONA DE PASE
      for (int i=0; i<11 && !bEnPase; i++){
        jRx = (int)(misContrarios[i].getX());
        jRy = (int)(misContrarios[i].getY());
        //ahora compruebo si el jugador esta dentro del rectangulo por el
        //metodo de los triangulos. Divido el rectangulo en dos triangulos:
        //LO-MN-LN y LO-MN-MO
        if (jugadorEnTriangulo(jRx, jRy, LOx, LOy, MNx, MNy, LNx, LNy) ||
            jugadorEnTriangulo(jRx, jRy, LOx, LOy, MNx, MNy, MOx, MOy)){
          bEnPase = true;
        }
      }
    } catch(Exception e){
      bEnPase = false;
    }
    
    return bEnPase;
  }
  
  //Se calcula la orientacion del triangulo. Saldra negativa o positiva. Si la orientacion de todos
  //los subtriangulos entre cada par de vertices y el jugador tambien es igual que la del triangulo
  //mayor, es que esta dentro del triangulo.
  private boolean jugadorEnTriangulo(int x, int y, int Ax, int Ay, int Bx, int By, int Cx, int Cy){
    int oriTriGrande, oriTriABX, oriTriCAX, oriTriBCX;
    
    oriTriGrande = (Ax-Cx)*(By-Cy)-(Ay-Cy)*(Bx-Cx);
    oriTriABX = (Ax-x)*(By-y)-(Ay-y)*(Bx-x);
    oriTriCAX = (Cx-x)*(Ay-y)-(Cy-y)*(Ax-x);
    oriTriBCX = (x-Cx)*(By-Cy)-(y-Cy)*(Bx-Cx);
    
    if (oriTriGrande < 0 && oriTriABX < 0 && oriTriCAX < 0 && oriTriBCX < 0)
      return true;
    else if (oriTriGrande > 0 && oriTriABX > 0 && oriTriCAX > 0 && oriTriBCX > 0)
      return true;
    else
      return false;
  }
  
  private void movimientoPortero(Vector com, int bx, int by){
    //obtengo coordenadas del balon
    int x, y;
    
    //coordenadas iniciales
    x = getXInicial(0);
    y = by;
    
    y = interpolacionMovimientoBalon(bx, by);
    //todos estos casos es si la interpolacion da que la pelota sale fuera de porteria
    //evito que se salga de los postes. Sigue balon si esta a la altura de porteria
    if ((y < -25 || y > 25) && by < -30) y = -25; //cubre poste superior
    if ((y < -25 || y > 25) && by > 30) y = 25; //cubre poste inferior
    if ((y < -25 || y > 25) && (by >= -30 && by <= 30)) y = by; //sigue la pelota
    //esto para el caso que la interpolacion de y=0. Es cuando la pelota queda muerta
    if (y == 0 && by > -30 && by < 30) y = by; //la pelota esta frente a porteria
    if (y == 0 && by < -30) y = -25; //poste superior
    if (y == 0 && by > 30) y = 25; //poste inferior
    //la pelota esta dentro del area parada, va a por ella
    if (y == 0 && by > -30 && by < 30 && bx < -130){
      x = bx;
      y = by;
    }
    
    com.add(new ComandoIrA(0, x, y));
  }
  
  private int interpolacionMovimientoBalon(int bx, int by){
    int y=0; //posicion y prevista para la pelota
    
    if (bx-xBolaAnt != 0) //evito la division por 0
      y = yBolaAnt + ((by-yBolaAnt)/(bx-xBolaAnt))*(getXInicial(0)-xBolaAnt);
    
    return y;
  }
  
  private void movimientoJugadores(Vector com, int nJugCercano, int nJugCercanoPase, int nJugCercanoPrevisto, int bx, int by){
    int dx, dy; //movimiento x,y de bola
    int mx=0, my=0; //hacia donde se dirigira el jugador. 1 der arr, 0 izq aba
    
    //obtengo el sentido del movimiento de la bola
    dx = bx - xBolaAnt;
    dy = by - yBolaAnt;
    
    //defino movimiento del jugador dentro de su zona horizontal
    if (bx < -105) mx = -1;
    else if (dx < 0 && bx < -50 && bx >= -105) mx = -1;
    else if (dx > 0 && bx > -50 && bx >= -105) mx = 1;
    
    //vertical. Segun donde este el balon
    if (by < -30) my = -1;
    else if (by >= -30 && by <= 30) my = 0;
    else if (by >= 30) my = 1;
    
    //muevo jugadores, excepto portero y jugador mas cercano y receptor de pase
    for (int n=1; n<11; n++){
      //para los defensas cuando ataca el rival
      if (bx < -105 && n<5 && n!=nJugCercano && n!=nJugCercanoPrevisto){
        com.add(new ComandoIrA(n, getXInicial(n)+(-2)*getZonaX(n), getYInicial(n)+my*getZonaY(n)));
      }
      //resto de jugadores y cuando el rival no ataca
      else if ((dx != 0 || dy != 0) && (n != nJugCercano) && (n != nJugCercanoPase) && (n!=nJugCercanoPrevisto)){
        com.add(new ComandoIrA(n, getXInicial(n)+mx*getZonaX(n), getYInicial(n)+my*getZonaY(n)));
      }
    }
  }
  
  //obtiene movimiento de zona en eje x del jugador
  private int getZonaX(int n){
    int valor=0; 
    
    if (iTactica%3 == 0) valor = zonaJugadores1[n][0];
    else if (iTactica%3 == 1) valor = zonaJugadores2[n][0];
    else if (iTactica%3 == 2) valor = zonaJugadores3[n][0];
    
    return valor;
  }
  
  //obtiene movimiento de zona en eje y del jugador
  private int getZonaY(int n){
    int valor=0;
    
    if (iTactica%3 == 0) valor = zonaJugadores1[n][1];
    else if (iTactica%3 == 1) valor = zonaJugadores2[n][1];
    else if (iTactica%3 == 2) valor = zonaJugadores3[n][1];
    
    return valor;
  }
}
